package dao

import (
	"errors"
	"fmt"
	"github.com/wonderivan/logger"
	"gorm.io/gorm"
	"k8s-platform/db"
	"k8s-platform/model"
)

var HostGroup hostgroup

type hostgroup struct{}

// 列表
func (*hostgroup) List() ([]*model.HostGroup, error) {
	hostgroups := []*model.HostGroup{}
	tx := db.DB.Preload("HostServers").Find(&hostgroups)
	if tx.Error != nil {
		logger.Error(fmt.Sprintf("获取Book列表失败，%v\n", tx.Error))
		return nil, errors.New(fmt.Sprintf("获取Book列表失败，%v\n", tx.Error))
	}
	return hostgroups, nil
}

// 新增
func (*hostgroup) Add(hostgroup *model.HostGroup) error {
	//创建hostgroup的时候不创建HostServers
	tx := db.DB.Omit("HostServers").Create(&hostgroup)
	if tx.Error != nil {
		logger.Error(fmt.Sprintf("添加group失败，%v\n", tx.Error))
		return errors.New(fmt.Sprintf("添加group失败，%v\n", tx.Error))
	}
	//添加hostgroup的时候关联HostServers
	if len(hostgroup.HostServers) > 0 {
		//处理关联添加
		err := db.DB.Model(&hostgroup).Association("HostServers").Append(hostgroup.HostServers)
		if err != nil {
			logger.Error(fmt.Sprintf("关联添加hostgroup:Servers失败，%v\n", tx.Error))
			return errors.New(fmt.Sprintf("关联添加hostgroup:Servers失败，%v\n", tx.Error))
		}
	}
	return nil
}

// 基于hostgroup查询单个，用于新增的时候判断hostgroup是否重复
func (*hostgroup) Has(hostgroup string) (*model.HostGroup, bool, error) {
	data := &model.HostGroup{}

	tx := db.DB.Where("group_name = ?", hostgroup).First(&data)
	if errors.As(tx.Error, &gorm.ErrRecordNotFound) {
		return nil, false, nil
	}
	if tx.Error != nil {
		logger.Error(fmt.Sprintf("查询group失败了, %v\n", tx.Error))
		return nil, false, errors.New(fmt.Sprintf("查询group失败了, %v\n", tx.Error))
	}
	return data, true, nil
}

// 基于id查询单个，用于查询单个详情
func (*hostgroup) Get(id int64) (*model.HostGroup, bool, error) {
	data := &model.HostGroup{}
	tx := db.DB.Where("id = ?", id).Preload("HostServers").First(&data)
	if errors.Is(tx.Error, gorm.ErrRecordNotFound) {
		return nil, false, nil
	}
	if tx.Error != nil {
		logger.Error(fmt.Sprintf("查询group组失败, %v\n", tx.Error))
		return nil, false, errors.New(fmt.Sprintf("查询group组失败, %v\n", tx.Error))
	}
	return data, true, nil
}

// 更新
func (*hostgroup) Update(hostgroup *model.HostGroup) error {
	//基于ID，更新单条hostgroup的所有数据
	//更新一般是在前端表格中某条数据的更新按钮，能拿到这条数据的所有内容，是list接口返回的
	//所以这里用Updates更新所有字段
	tx := db.DB.Model(&model.HostGroup{}).Where("id = ?", hostgroup.ID).Updates(&hostgroup)
	if tx.Error != nil {
		logger.Error(fmt.Sprintf("更新hostgroup失败, %v\n", tx.Error))
		return errors.New(fmt.Sprintf("更新hostgroup失败, %v\n", tx.Error))
	}
	//if len(hostgroup.HostServers) > 0 {
	//	//关联更新用户，Association.Replace
	//	err := db.DB.Model(&hostgroup).Association("HostServers").Replace(hostgroup.HostServers)
	//	if err.Error != nil {
	//		logger.Error(fmt.Sprintf("关联更新hostgroup:HostServer失败1, %v\n", err))
	//		return errors.New(fmt.Sprintf("关联更新hostgroup:HostServer失败1, %v\n", err))
	//	}
	//} else {
	//	//关联清空用户，使用Association.Clear
	//	err := db.DB.Model(&hostgroup).Association("HostServers").Clear()
	//	if err.Error != nil {
	//		logger.Error(fmt.Sprintf("关联更新hostgroup:HostServer失败2, %v\n", err))
	//		return errors.New(fmt.Sprintf("关联更新hostgroup:HostServer失败2, %v\n", err))
	//	}
	//}
	return nil
}

// 删除
func (*hostgroup) Delete(hostgroup *model.HostGroup, id int64) error {

	err := db.DB.Model(&hostgroup).Association("HostServers").Clear()
	if err != nil {
		logger.Error("关联删除Role:Permission失败, " + err.Error())
		return errors.New("关联删除Role:Permission失败, " + err.Error())
	}

	//再删除hostgroup数据
	tx := db.DB.Where("id = ?", id).Delete(&model.HostGroup{})
	if tx.Error != nil {
		logger.Error("删除group失败, " + tx.Error.Error())
		return errors.New("删除group失败, " + tx.Error.Error())
	}

	return nil
}
